A constant feature in Q&A columns are C definitions. Like every thing else about the language, they are laconic and occult, proving difficult to program or comprehend. Some overcome this intricity with aid of a utility -- one that explains C definitions in English you can read. It works fine, if all you intend it is to decipher other's definitions. For creating them, however, an amount of trial and error is involved before you get things right.
The treatment I have adopted is of different orientation. The opposite, to be exact: Define constructs definitions from descriptions given to it in plain English. Just tell it what you want, like you write a columnist -- it works the first time.
How Simple Can It Be
Define employs no AI techniques, yet is capable of handling sentences as natural as:
foo is function returning pointer to array of int.
which comes out the other way as:
int (*foo())[];
The secret lies in the simplicity of the rules governing the construction of definitions -- they are not nearly as hard as you may think them to be.
The first thing Define does with an English description is copy the identifier name (if present) into a malloced memory block. It then proceeds to read the descriptors (pointer, function and array), prefixing and postfixing the identifier with C tokens in accordance; the memory block expands to accommodate the growing definition. Following are the construction rules:
Descriptor Action
pointer to Precede with *
pointer to function Precede with *, Enclose definition with (..)
pointer to array Precede with *, Enclose definition with (..)
function returning Append ()
array of Append []
Given the previous sentence, Define:
Appends (), foo()
Prefixes an *, *foo()
Encloses with (..), (*foo())
and Appends []. (*foo())[]
The rest of the description is assumed to be the data type: returned, pointed to, or array element. It copies in full to the start of the definition, completing it to:
int (*foo())[];
While creating your definitions, Define warns for the following three illegal combinations:
Array of function
Function returning array
and
Function returning function
As you become familiar with Define, you will develop the habit of taking shortcuts: the is following the identifier name can be dropped; so can to, returning and of; function truncates to just func, returning to return (or nothing), and pointer to poin or simply ptr.
How Complex Can It Be
Define does not suffice in constructing only the complicated parts of your definitions: you can hand it over the most complete definitions, including within the size of arrays and the parameters accepted by functions.
To indicate the dimension of an array, follow array with size, eg:
bar is array size 6 of array size 4 of int.
to produce:
int bar[6][4];
A function's formal parameters you state by proceeding function with accepting (shorthand accept) and a parenthesized list of the parameters. Given:
foo func accept (a ptr int, b array char) return int.
Define will return:
int foo(int *a, char b[]);
If you program the K&R style, you may consider this capability somewhat redundant. Not so if you follow the ANSI standard -- it demands that you prototype all function definitions and declarations. As well as pointers to functions.
Conclusion
In this article, I have not gone into detail with the internals of Define. It was not intended as a listing to study and hack. Rather, Define is a utility, originated to make life easier for all you programmers struggling with the C programming language. You'll need all the help you can get.
